{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-03-03T01:54:11.693657Z",
     "start_time": "2020-03-03T01:54:11.686677Z"
    }
   },
   "outputs": [],
   "source": [
    "from sklearn.utils import shuffle\n",
    "from sklearn.model_selection import train_test_split\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "MAX_ITERATION = 10000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-03-03T05:37:10.339950Z",
     "start_time": "2020-03-03T05:37:10.279114Z"
    }
   },
   "outputs": [],
   "source": [
    "def logistic_data_generator(mean1, cov1, mean2, cov2, num):\n",
    "    np.random.seed(0)\n",
    "    X = np.random.multivariate_normal(mean1, cov1, num//2)\n",
    "    np.random.seed(1)\n",
    "    y = np.full(num//2, -1, dtype=int)\n",
    "    X_ = np.random.multivariate_normal(mean2, cov2, num-num//2)\n",
    "    y_ = np.full(num-num//2, 1, dtype=int)\n",
    "\n",
    "    X_train, X_test, y_train, y_test = train_test_split(\n",
    "        X, y, test_size=50, random_state=1)\n",
    "    X_train_, X_test_, y_train_, y_test_ = train_test_split(\n",
    "        X_, y_, test_size=50, random_state=2)\n",
    "    X_train = np.concatenate((X_train, X_train_), axis=0)\n",
    "    X_test = np.concatenate((X_test, X_test_), axis=0)\n",
    "    y_train = np.concatenate((y_train, y_train_))\n",
    "    y_test = np.concatenate((y_test, y_test_))\n",
    "\n",
    "    X_train, y_train = shuffle(X_train, y_train)\n",
    "    X_test, y_test = shuffle(X_test, y_test)\n",
    "\n",
    "    return X_train, y_train, X_test, y_test\n",
    "\n",
    "\n",
    "def LDA_data_generator(mean1, cov1, mean2, cov2, num):\n",
    "    np.random.seed(0)\n",
    "    X = np.random.multivariate_normal(mean1, cov1, num//2)\n",
    "    np.random.seed(1)\n",
    "    y = np.full(num//2, -1, dtype=int)\n",
    "    X_ = np.random.multivariate_normal(mean2, cov2, num-num//2)\n",
    "    y_ = np.full(num-num//2, 1, dtype=int)\n",
    "    X1 = np.concatenate((X, X_), axis=0)\n",
    "    y1 = np.concatenate((y, y_))\n",
    "\n",
    "    return shuffle(X1, y1)\n",
    "\n",
    "\n",
    "def draw_logistic(X, y, w):\n",
    "    fig, ax = plt.subplots(1, 1, figsize=(12, 5))\n",
    "\n",
    "    for i in range(len(y)):\n",
    "        if y[i] == 1:\n",
    "            ax.scatter(X[i, 0], X[i, 1], c='r', marker='o')\n",
    "        else:\n",
    "            ax.scatter(X[i, 0], X[i, 1], c='b', marker='x')\n",
    "\n",
    "    l_x = np.linspace(np.min(X), np.max(X), X.shape[0])\n",
    "    l_y = -(w[0]/w[2]+w[1]/w[2]*l_x)\n",
    "    ax.plot(l_x, l_y)\n",
    "    xy_max = np.max(X, axis=0)\n",
    "    ax.set(xlim=(-xy_max[0]-1, xy_max[0]+1), ylim=(-xy_max[1]-1, xy_max[1]+1),\n",
    "           xlabel=\"x\",\n",
    "           ylabel=\"y\",\n",
    "           title=\"Logistic Regression\")\n",
    "\n",
    "\n",
    "def draw_LDA(X, y, w, st):\n",
    "    fig, ax = plt.subplots(1, 1, figsize=(12, 5))\n",
    "\n",
    "    for i in range(len(y)):\n",
    "        if y[i] == 1:\n",
    "            ax.scatter(X[i, 0], X[i, 1], c='r', marker='o')\n",
    "        else:\n",
    "            ax.scatter(X[i, 0], X[i, 1], c='b', marker='x')\n",
    "\n",
    "    l_x = np.linspace(np.min(X), np.max(X), X.shape[0])\n",
    "    l_y = -w[0]/w[1]*l_x+st/w[1]\n",
    "    ax.plot(l_x, l_y)\n",
    "    w_x = np.linspace(np.min(X), np.max(X), X.shape[0])\n",
    "    w_y = w[1]/w[0]*w_x\n",
    "    ax.plot(w_x, w_y)\n",
    "    xy_max = np.max(X, axis=0)\n",
    "    ax.set(xlim=(-xy_max[0]-1, xy_max[0]+1), ylim=(-xy_max[1]-1, xy_max[1]+1),\n",
    "           xlabel=\"x\",\n",
    "           ylabel=\"y\",\n",
    "           title=\"LDA\")\n",
    "\n",
    "\n",
    "def draw_kmeans(recorder):\n",
    "    assert len(\n",
    "        recorder[-1]) <= 7, 'k should be less than or equal to 7, otherwise it is hard to observe the result'\n",
    "    fig, ax = plt.subplots(1, 1, figsize=(7, 7))\n",
    "    colors = ['b', 'r', 'g', 'k', 'y', 'c', 'm']\n",
    "\n",
    "    for index, (centroid, cluster) in enumerate(recorder[-1].items()):\n",
    "        ax.scatter(np.array(cluster)[:, 0], np.array(cluster)[\n",
    "                   :, 1], s=100, marker='+', c=colors[index])\n",
    "        ax.scatter(centroid[0], centroid[1], s=150,\n",
    "                   marker='o', c=colors[index])\n",
    "\n",
    "\n",
    "def logistic_train(X_train, y_train, w_init, max_iter, lr=0.001, eps=1e-10):\n",
    "    def sigmoid(s):\n",
    "        return np.exp(s)/(1 + np.exp(s))\n",
    "\n",
    "    w = w_init\n",
    "    X = np.concatenate((np.ones((X_train.shape[0], 1)), X_train), axis=1)\n",
    "    y = y_train\n",
    "\n",
    "    for i in range(max_iter):\n",
    "        for j in range(X.shape[0]):\n",
    "            diff = sigmoid(-y[j]*np.dot(w, X[j]))*(-y[j]*X[j])\n",
    "            w_ = w - lr * diff\n",
    "\n",
    "            delta = np.linalg.norm(w - w_)\n",
    "            if delta < eps:\n",
    "                break\n",
    "            else:\n",
    "                w = w_\n",
    "    return w\n",
    "\n",
    "\n",
    "def logistic_test(X_test, y_test, w):\n",
    "    def sigmoid(s):\n",
    "        return np.exp(s)/(1 + np.exp(s))\n",
    "\n",
    "    X = np.concatenate((np.ones((X_test.shape[0], 1)), X_test), axis=1)\n",
    "    y = y_test\n",
    "\n",
    "    h = np.sign(2*sigmoid(np.dot(X, w))-1)\n",
    "    p = sigmoid(np.dot(X, w))\n",
    "    mistake_indices = np.where(h != y)[0]\n",
    "    mistake_num = len(mistake_indices)\n",
    "    CE = 1/(X.shape[0]) * np.sum(np.log(1+np.exp(-y*np.dot(X, w))))\n",
    "    print('CE is', CE)\n",
    "    print('Accuracy is %.2f%%' %\n",
    "          (100*(X.shape[0]-mistake_num)/X.shape[0]))\n",
    "    for i in range(X.shape[0]):\n",
    "        print('样本[%.2f, %.2f]属于-1/1类的概率分别为：[%f, %f]，因此属于%d类'\n",
    "              % (X[i][1], X[i][2], 1-p[i], p[i], h[i]))\n",
    "\n",
    "    draw_logistic(X_test, y_test, w)\n",
    "\n",
    "\n",
    "def LDA(X, y):\n",
    "    w1 = X[np.where(y == -1)]\n",
    "    w2 = X[np.where(y == 1)]\n",
    "    assert w1.shape[1] == w2.shape[1], 'Identical dimension of data should be guaranteed'\n",
    "\n",
    "    m1 = np.average(w1, axis=0)\n",
    "    m2 = np.average(w2, axis=0)\n",
    "    n = w1.shape[1]\n",
    "\n",
    "    c1 = np.zeros((n, n))\n",
    "    for i in range(w1.shape[0]):\n",
    "        c1 = c1 + np.dot((w1 - m1)[i].reshape(-1, 1),\n",
    "                         (w1 - m1)[i].reshape(1, -1))\n",
    "    c2 = np.zeros((n, n))\n",
    "    for i in range(w2.shape[0]):\n",
    "        c2 = c2 + np.dot((w2 - m2)[i].reshape(-1, 1),\n",
    "                         (w2 - m2)[i].reshape(1, -1))\n",
    "    c = c1 + c2\n",
    "\n",
    "    w = np.linalg.pinv(c).dot((m1 - m2))\n",
    "    m1_ = np.dot(w, m1)\n",
    "    m2_ = np.dot(w, m2)\n",
    "    st = 1/2 * (m1_ + m2_)\n",
    "\n",
    "    print(\"最佳投影向量：\", w)\n",
    "    print(\"分类阈值：\", st)\n",
    "\n",
    "    return w, st\n",
    "\n",
    "\n",
    "def kmeans(X, k):\n",
    "    def random_centroids(X, k):\n",
    "        random_index = np.random.choice(X.shape[0], k, replace=False)\n",
    "        return X[random_index]\n",
    "\n",
    "    def update_centroids(epoch):\n",
    "        new_centroids = []\n",
    "        for i in epoch.values():\n",
    "            new_centroids.append(np.average(np.array(i), axis=0))\n",
    "        return np.array(new_centroids)\n",
    "\n",
    "    assert k <= X.shape[0], 'k should be less than or equal to the number of examples'\n",
    "\n",
    "    centroids = random_centroids(X, k)\n",
    "    recorder = []\n",
    "    converged = False\n",
    "\n",
    "    while not converged:\n",
    "        epoch = {tuple(i): [] for i in centroids}\n",
    "        for i in range(len(X)):\n",
    "            min_dist = np.inf\n",
    "            min_centroid = (np.inf, np.inf)\n",
    "            for j in epoch.keys():\n",
    "                dist = np.linalg.norm(X[i]-j)\n",
    "                if min_dist > dist:\n",
    "                    min_dist = dist\n",
    "                    min_centroid = j\n",
    "            epoch[min_centroid].append(X[i])\n",
    "        recorder.append(epoch)\n",
    "        new_centroids = update_centroids(epoch)\n",
    "        if (new_centroids == centroids).all():\n",
    "            converged = True\n",
    "        else:\n",
    "            centroids = new_centroids\n",
    "\n",
    "    return recorder"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Logistic Regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-03-03T05:37:42.639579Z",
     "start_time": "2020-03-03T05:37:11.714931Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CE is 6.042771553259536e-05\n",
      "Accuracy is 100.00%\n",
      "样本[3.56, -0.50]属于-1/1类的概率分别为：[0.000104, 0.999896]，因此属于1类\n",
      "样本[4.73, 0.53]属于-1/1类的概率分别为：[0.000006, 0.999994]，因此属于1类\n",
      "样本[-4.14, -0.74]属于-1/1类的概率分别为：[0.999963, 0.000037]，因此属于-1类\n",
      "样本[4.86, -0.12]属于-1/1类的概率分别为：[0.000004, 0.999996]，因此属于1类\n",
      "样本[-5.03, 0.43]属于-1/1类的概率分别为：[0.999997, 0.000003]，因此属于-1类\n",
      "样本[5.12, 1.13]属于-1/1类的概率分别为：[0.000002, 0.999998]，因此属于1类\n",
      "样本[-4.36, -1.62]属于-1/1类的概率分别为：[0.999977, 0.000023]，因此属于-1类\n",
      "样本[-4.42, 0.35]属于-1/1类的概率分别为：[0.999984, 0.000016]，因此属于-1类\n",
      "样本[5.87, -2.30]属于-1/1类的概率分别为：[0.000000, 1.000000]，因此属于1类\n",
      "样本[-5.06, -0.11]属于-1/1类的概率分别为：[0.999997, 0.000003]，因此属于-1类\n",
      "样本[-5.65, -0.52]属于-1/1类的概率分别为：[0.999999, 0.000001]，因此属于-1类\n",
      "样本[4.29, 1.19]属于-1/1类的概率分别为：[0.000019, 0.999981]，因此属于1类\n",
      "样本[4.88, -0.18]属于-1/1类的概率分别为：[0.000004, 0.999996]，因此属于1类\n",
      "样本[5.28, -0.73]属于-1/1类的概率分别为：[0.000001, 0.999999]，因此属于1类\n",
      "样本[-3.51, -2.07]属于-1/1类的概率分别为：[0.999797, 0.000203]，因此属于-1类\n",
      "样本[-5.31, 0.06]属于-1/1类的概率分别为：[0.999998, 0.000002]，因此属于-1类\n",
      "样本[-3.77, 1.20]属于-1/1类的概率分别为：[0.999923, 0.000077]，因此属于-1类\n",
      "样本[5.87, 0.75]属于-1/1类的概率分别为：[0.000000, 1.000000]，因此属于1类\n",
      "样本[4.82, -0.60]属于-1/1类的概率分别为：[0.000004, 0.999996]，因此属于1类\n",
      "样本[-5.10, 0.41]属于-1/1类的概率分别为：[0.999997, 0.000003]，因此属于-1类\n",
      "样本[-3.47, 1.47]属于-1/1类的概率分别为：[0.999839, 0.000161]，因此属于-1类\n",
      "样本[-5.44, -0.28]属于-1/1类的概率分别为：[0.999999, 0.000001]，因此属于-1类\n",
      "样本[-5.96, -0.35]属于-1/1类的概率分别为：[1.000000, 0.000000]，因此属于-1类\n",
      "样本[3.80, 0.86]属于-1/1类的概率分别为：[0.000064, 0.999936]，因此属于1类\n",
      "样本[-6.16, -0.31]属于-1/1类的概率分别为：[1.000000, 0.000000]，因此属于-1类\n",
      "样本[-5.63, -0.36]属于-1/1类的概率分别为：[0.999999, 0.000001]，因此属于-1类\n",
      "样本[4.96, 2.11]属于-1/1类的概率分别为：[0.000004, 0.999996]，因此属于1类\n",
      "样本[-3.64, -0.69]属于-1/1类的概率分别为：[0.999872, 0.000128]，因此属于-1类\n",
      "样本[4.88, -0.94]属于-1/1类的概率分别为：[0.000004, 0.999996]，因此属于1类\n",
      "样本[7.05, 0.59]属于-1/1类的概率分别为：[0.000000, 1.000000]，因此属于1类\n",
      "样本[-5.81, -1.73]属于-1/1类的概率分别为：[0.999999, 0.000001]，因此属于-1类\n",
      "样本[-5.69, -1.21]属于-1/1类的概率分别为：[0.999999, 0.000001]，因此属于-1类\n",
      "样本[-5.60, -0.24]属于-1/1类的概率分别为：[0.999999, 0.000001]，因此属于-1类\n",
      "样本[-5.89, -1.98]属于-1/1类的概率分别为：[1.000000, 0.000000]，因此属于-1类\n",
      "样本[-4.27, 0.13]属于-1/1类的概率分别为：[0.999976, 0.000024]，因此属于-1类\n",
      "样本[-4.39, 0.92]属于-1/1类的概率分别为：[0.999983, 0.000017]，因此属于-1类\n",
      "样本[-5.91, 0.05]属于-1/1类的概率分别为：[1.000000, 0.000000]，因此属于-1类\n",
      "样本[5.04, 0.58]属于-1/1类的概率分别为：[0.000003, 0.999997]，因此属于1类\n",
      "样本[-4.14, 1.14]属于-1/1类的概率分别为：[0.999970, 0.000030]，因此属于-1类\n",
      "样本[5.16, -0.19]属于-1/1类的概率分别为：[0.000002, 0.999998]，因此属于1类\n",
      "样本[-5.74, 1.54]属于-1/1类的概率分别为：[0.999999, 0.000001]，因此属于-1类\n",
      "样本[5.80, -0.37]属于-1/1类的概率分别为：[0.000000, 1.000000]，因此属于1类\n",
      "样本[6.41, 0.13]属于-1/1类的概率分别为：[0.000000, 1.000000]，因此属于1类\n",
      "样本[-5.86, 1.91]属于-1/1类的概率分别为：[1.000000, 0.000000]，因此属于-1类\n",
      "样本[4.12, -0.87]属于-1/1类的概率分别为：[0.000024, 0.999976]，因此属于1类\n",
      "样本[-5.02, 0.38]属于-1/1类的概率分别为：[0.999996, 0.000004]，因此属于-1类\n",
      "样本[-5.46, 0.02]属于-1/1类的概率分别为：[0.999999, 0.000001]，因此属于-1类\n",
      "样本[-5.91, 1.12]属于-1/1类的概率分别为：[1.000000, 0.000000]，因此属于-1类\n",
      "样本[-6.17, 0.90]属于-1/1类的概率分别为：[1.000000, 0.000000]，因此属于-1类\n",
      "样本[6.56, 0.11]属于-1/1类的概率分别为：[0.000000, 1.000000]，因此属于1类\n",
      "样本[4.80, 0.81]属于-1/1类的概率分别为：[0.000005, 0.999995]，因此属于1类\n",
      "样本[4.89, -0.62]属于-1/1类的概率分别为：[0.000004, 0.999996]，因此属于1类\n",
      "样本[5.11, -1.53]属于-1/1类的概率分别为：[0.000002, 0.999998]，因此属于1类\n",
      "样本[5.24, 0.20]属于-1/1类的概率分别为：[0.000002, 0.999998]，因此属于1类\n",
      "样本[5.19, 0.41]属于-1/1类的概率分别为：[0.000002, 0.999998]，因此属于1类\n",
      "样本[-3.35, 0.16]属于-1/1类的概率分别为：[0.999757, 0.000243]，因此属于-1类\n",
      "样本[5.35, -1.31]属于-1/1类的概率分别为：[0.000001, 0.999999]，因此属于1类\n",
      "样本[-6.29, 0.27]属于-1/1类的概率分别为：[1.000000, 0.000000]，因此属于-1类\n",
      "样本[-4.05, -0.16]属于-1/1类的概率分别为：[0.999957, 0.000043]，因此属于-1类\n",
      "样本[-6.07, 1.05]属于-1/1类的概率分别为：[1.000000, 0.000000]，因此属于-1类\n",
      "样本[5.74, -0.95]属于-1/1类的概率分别为：[0.000000, 1.000000]，因此属于1类\n",
      "样本[3.78, 2.45]属于-1/1类的概率分别为：[0.000078, 0.999922]，因此属于1类\n",
      "样本[-5.81, -1.47]属于-1/1类的概率分别为：[0.999999, 0.000001]，因此属于-1类\n",
      "样本[-5.21, 0.88]属于-1/1类的概率分别为：[0.999998, 0.000002]，因此属于-1类\n",
      "样本[-4.72, -0.99]属于-1/1类的概率分别为：[0.999991, 0.000009]，因此属于-1类\n",
      "样本[5.30, -0.35]属于-1/1类的概率分别为：[0.000001, 0.999999]，因此属于1类\n",
      "样本[-5.94, -0.41]属于-1/1类的概率分别为：[1.000000, 0.000000]，因此属于-1类\n",
      "样本[-3.04, 0.39]属于-1/1类的概率分别为：[0.999483, 0.000517]，因此属于-1类\n",
      "样本[5.44, 1.12]属于-1/1类的概率分别为：[0.000001, 0.999999]，因此属于1类\n",
      "样本[5.46, -1.18]属于-1/1类的概率分别为：[0.000001, 0.999999]，因此属于1类\n",
      "样本[-4.64, 0.71]属于-1/1类的概率分别为：[0.999991, 0.000009]，因此属于-1类\n",
      "样本[4.73, 0.03]属于-1/1类的概率分别为：[0.000006, 0.999994]，因此属于1类\n",
      "样本[-5.87, -0.58]属于-1/1类的概率分别为：[1.000000, 0.000000]，因此属于-1类\n",
      "样本[5.19, 2.10]属于-1/1类的概率分别为：[0.000002, 0.999998]，因此属于1类\n",
      "样本[5.10, 0.92]属于-1/1类的概率分别为：[0.000002, 0.999998]，因此属于1类\n",
      "样本[4.76, 0.73]属于-1/1类的概率分别为：[0.000006, 0.999994]，因此属于1类\n",
      "样本[6.20, 0.19]属于-1/1类的概率分别为：[0.000000, 1.000000]，因此属于1类\n",
      "样本[-4.25, -1.19]属于-1/1类的概率分别为：[0.999972, 0.000028]，因此属于-1类\n",
      "样本[4.83, -0.17]属于-1/1类的概率分别为：[0.000004, 0.999996]，因此属于1类\n",
      "样本[4.14, 0.67]属于-1/1类的概率分别为：[0.000027, 0.999973]，因此属于1类\n",
      "样本[-5.27, -1.13]属于-1/1类的概率分别为：[0.999998, 0.000002]，因此属于-1类\n",
      "样本[5.29, 0.89]属于-1/1类的概率分别为：[0.000002, 0.999998]，因此属于1类\n",
      "样本[3.90, 1.14]属于-1/1类的概率分别为：[0.000051, 0.999949]，因此属于1类\n",
      "样本[-5.39, -0.30]属于-1/1类的概率分别为：[0.999999, 0.000001]，因此属于-1类\n",
      "样本[-5.99, -1.47]属于-1/1类的概率分别为：[1.000000, 0.000000]，因此属于-1类\n",
      "样本[4.35, 0.90]属于-1/1类的概率分别为：[0.000016, 0.999984]，因此属于1类\n",
      "样本[-4.48, -0.17]属于-1/1类的概率分别为：[0.999985, 0.000015]，因此属于-1类\n",
      "样本[-6.27, 0.97]属于-1/1类的概率分别为：[1.000000, 0.000000]，因此属于-1类\n",
      "样本[2.21, 1.94]属于-1/1类的概率分别为：[0.003909, 0.996091]，因此属于1类\n",
      "样本[4.66, 0.04]属于-1/1类的概率分别为：[0.000007, 0.999993]，因此属于1类\n",
      "样本[6.74, -0.76]属于-1/1类的概率分别为：[0.000000, 1.000000]，因此属于1类\n",
      "样本[-6.76, 0.45]属于-1/1类的概率分别为：[1.000000, 0.000000]，因此属于-1类\n",
      "样本[6.46, -2.06]属于-1/1类的概率分别为：[0.000000, 1.000000]，因此属于1类\n",
      "样本[-4.60, -1.09]属于-1/1类的概率分别为：[0.999988, 0.000012]，因此属于-1类\n",
      "样本[4.45, -0.20]属于-1/1类的概率分别为：[0.000011, 0.999989]，因此属于1类\n",
      "样本[4.22, -0.44]属于-1/1类的概率分别为：[0.000020, 0.999980]，因此属于1类\n",
      "样本[-4.93, 0.30]属于-1/1类的概率分别为：[0.999996, 0.000004]，因此属于-1类\n",
      "样本[4.68, -0.38]属于-1/1类的概率分别为：[0.000006, 0.999994]，因此属于1类\n",
      "样本[5.62, -0.44]属于-1/1类的概率分别为：[0.000001, 0.999999]，因此属于1类\n",
      "样本[5.90, -0.68]属于-1/1类的概率分别为：[0.000000, 1.000000]，因此属于1类\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "X1_train, y1_train, X1_test, y1_test = logistic_data_generator([-5, 0], \n",
    "                                                               np.identity(2), \n",
    "                                                               [5, 0], \n",
    "                                                               np.identity(2), 400)\n",
    "np.random.seed()\n",
    "w_init = np.random.randn(3)\n",
    "w1 = logistic_train(X1_train, y1_train, w_init, MAX_ITERATION)\n",
    "logistic_test(X1_test, y1_test, w)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Fisher Discriminant Analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-03-02T17:08:38.586094Z",
     "start_time": "2020-03-02T17:08:37.349399Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "最佳投影向量： [-0.02629717 -0.00222113]\n",
      "分类阈值： -8.890360166412259e-05\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "X2, y2 = LDA_data_generator([-5, 0], np.identity(2), [5, 0], np.identity(2), 400)\n",
    "w2, st = LDA(X2, y2)\n",
    "draw_LDA(X2, y2, w2, st)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# K-Means"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X3 = np.array([[0.697, 0.460],\n",
    "               [0.774, 0.376],\n",
    "               [0.634, 0.264],\n",
    "               [0.608, 0.318],\n",
    "               [0.556, 0.215],\n",
    "               [0.403, 0.237],\n",
    "               [0.481, 0.149],\n",
    "               [0.437, 0.211],\n",
    "               [0.666, 0.091],\n",
    "               [0.243, 0.267],\n",
    "               [0.245, 0.057],\n",
    "               [0.343, 0.099],\n",
    "               [0.639, 0.161],\n",
    "               [0.657, 0.198],\n",
    "               [0.360, 0.370],\n",
    "               [0.593, 0.042],\n",
    "               [0.719, 0.103],\n",
    "               [0.359, 0.188],\n",
    "               [0.339, 0.241],\n",
    "               [0.282, 0.257],\n",
    "               [0.748, 0.232],\n",
    "               [0.714, 0.346],\n",
    "               [0.483, 0.312],\n",
    "               [0.478, 0.437],\n",
    "               [0.525, 0.369],\n",
    "               [0.751, 0.489],\n",
    "               [0.532, 0.472],\n",
    "               [0.473, 0.376],\n",
    "               [0.725, 0.445],\n",
    "               [0.446, 0.459]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-03-02T07:43:27.826723Z",
     "start_time": "2020-03-02T07:43:27.671137Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "recorder = kmeans(X3, 3)\n",
    "draw_kmeans(recorder)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-03-02T07:42:44.011219Z",
     "start_time": "2020-03-02T07:42:43.833692Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "recorder = kmeans(X3, 5)\n",
    "draw_kmeans(recorder)"
   ]
  }
 ],
 "metadata": {
  "hide_input": false,
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
